home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / tools / dfÜ / bbs / tronbbs / tron / docs / demodoor / adoor.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  17.9 KB  |  800 lines
  1.  
  2.  
  3. /*  Tron BBS 'Additional Clidoor Support' system functions              */
  4. /*                                                                      */
  5. /*  V 1.00   25 - 11 - 1995                                             */
  6. /*                                                                      */
  7. /*  (c) Copyright 1995 by Paul Spijkerman                               */
  8.  
  9.  
  10.  
  11. #include  "adoor.h"
  12.  
  13.  
  14. int  SendMessage    (struct ADS_Data *p);
  15. int  SafePutToPort  (struct Message *, STRPTR);
  16.  
  17.  
  18.  
  19.  
  20. /*===( Input / Output code )=================================*/
  21.  
  22.  
  23. void SetOpIO(struct DoorIO *p)
  24. {
  25.    p->ConInput  = Input();
  26.    p->ConOutput = Output();
  27.  
  28.    p->carrier = 1;
  29.  
  30.    SetMode (p->ConInput , 1);     /* RAW: mode */
  31.  
  32.    p->xmax = 80;
  33.    p->ymax = 40;
  34.  
  35.    norm(p);      /*   mfc, mbc, mhigh  */
  36.    cls (p);      /*   mx,  my          */
  37. }
  38.  
  39.  
  40. void RemoveIO(struct DoorIO *p)
  41. {
  42.    SetMode (p->ConInput , 0);     /* CON: mode */
  43. }
  44.  
  45.  
  46. UBYTE GetCharacter(struct DoorIO *p)
  47. {
  48.    UBYTE c = 0, getstring[3];
  49.  
  50.    while (c == 0 && p->carrier){
  51.       if (0 != WaitForChar( p->ConInput ,10000)){
  52.          Read( p->ConInput , getstring, 1);
  53.          c = getstring[0];
  54.          if (c == 3) p->carrier = 0;        /* carrier lost */
  55.       }
  56.    }
  57.    return c;
  58. }
  59.  
  60.  
  61. UBYTE MayGetCharacter(struct DoorIO *p)
  62. {
  63.    UBYTE  c = 0, getstring[3];
  64.    getstring[0] = '\0';
  65.  
  66.    if (0 != WaitForChar( p->ConInput , 0)){
  67.       Read( p->ConInput , getstring, 1);      /* IPV getstring -> &c */
  68.       c = getstring[0];
  69.       if (c == 3) p->carrier = 0;             /* carrier lost */
  70.    }
  71.    return c;
  72. }
  73.  
  74.  
  75. int  GetString(struct DoorIO *p, char *str, int strsize)
  76. {
  77.    int   len = 0, pos = 0, t, d;
  78.    UBYTE kar;
  79.  
  80.    while (len < strsize-1 && '\r' != (kar = GetCharacter(p)) &&  Carrier(p)){
  81.  
  82.       /* cursor ->    (2+pos, y) */
  83.       /* nprintf(p, "%d;%dH",27,7 + pos); */
  84.  
  85.       switch (kar){
  86.  
  87.          case 8:                              /* case of backspace */
  88.             if (pos > 0){
  89.                nprintf(p, "D");
  90.                for (t = pos - 1; t < len - 1; t++)
  91.                   nprintf(p, "%c", str[t] = str[t+1] );
  92.                nprintf(p, "%c", str[len-1] = ' ' );
  93.                d = len - pos + 1;
  94.                nprintf(p, "%dD", d);
  95.                len--;
  96.                pos--;
  97.             }
  98.          break;
  99.  
  100.          case 0x7f:                           /* case of Delete */
  101.             if (len > 0 && pos < len){
  102.                for (t = pos; t < len - 1; t++)
  103.                   nprintf(p, "%c", str[t] = str[t+1] );
  104.                nprintf(p, "%c", str[len-1] = ' ' );
  105.                d = len - pos;
  106.                nprintf(p, "%dD", d);
  107.                len--;
  108.             }
  109.          break;
  110.  
  111.          case    0:
  112.          case    3:                           /* ignore Ctrl-c   */
  113.          case '\n':                           /* ignore newlines */
  114.          break;
  115.  
  116.          case 0x1b:                           /* escape (sequence) */
  117.             kar = GetCharacter(p);
  118.             if (kar == '['){
  119.                kar = GetCharacter(p);
  120.                if (kar == 'D'){               /* backward */
  121.                   if (pos > 0){
  122.                      pos--;
  123.                      nprintf(p, "D");
  124.                   }
  125.                }
  126.                if (kar == 'C'){               /* forward  */
  127.                   if (pos < len){
  128.                      pos++;
  129.                      nprintf(p, "C");
  130.                   }
  131.                }
  132.             }
  133.          break;
  134.  
  135.          default:
  136. /*
  137.             str[pos++] = kar;
  138.             if (pos > len)  len = pos;
  139.             nprintf(p, "%c", kar);
  140. */
  141.             if (pos == len){
  142.                str[pos++] = kar;
  143.                if (pos > len)  len = pos;
  144.                nprintf(p, "%c", kar);
  145.             }else{
  146.                for (t = len; t >= pos; t--)
  147.                   str[t+1] = str[t];
  148.                str[pos] = kar;
  149.  
  150.                for (t = pos; t <= len; t++)
  151.                   nprintf(p, "%c", str[t]);
  152.  
  153.                d = len - pos;
  154.                nprintf(p, "%dD", d);
  155.                len++;
  156.                pos++;
  157.             }
  158.          break;
  159.  
  160.       }
  161.    }
  162.    str[len] = '\0';
  163.    /* nprintf(p, "\r\n"); */
  164.    return len;
  165. }
  166.  
  167.  
  168. int Carrier(struct DoorIO *p)        /* voor de compleet heid :) */
  169. {
  170.    return (p->carrier);
  171. }
  172.  
  173.  
  174. int nprintf(struct DoorIO *p, char *fmt, ...)
  175. {
  176.    int len;
  177.    va_list var_args;
  178.    char str[120];
  179.  
  180.    va_start(var_args, fmt);
  181.    len = (int) vsprintf(str, fmt, var_args);    /* of eigen brouwsel */
  182.    va_end(var_args);
  183.  
  184.    PutStr (str);
  185.    Flush  (p->ConOutput);
  186.    return (len);
  187. }
  188.  
  189.  
  190. int brk(void)
  191. {
  192.    return (0);
  193. }
  194.  
  195.  
  196. /*===( FileMark / Download code )=================================*/
  197.  
  198.  
  199. int  SetopPort(struct ADS_Data *p, int node, int quiet)
  200. {
  201.    int ret = 0;
  202.  
  203.    p->node    = node;
  204.    p->quiet   = quiet;
  205.    p->BBSMsg  = NULL;
  206.    p->BBSreplyport = NULL;
  207.    p->IDMode  = 0;
  208.  
  209.    if (p->node >= 0 && p->node < 10){
  210.       if (p->BBSreplyport = CreatePort(0,0)){
  211.          if (p->BBSMsg = (struct ADoorMessage *) AllocMem(sizeof(struct ADoorMessage), MEMF_PUBLIC | MEMF_CLEAR)){
  212.             p->BBSMsg->ADS_Msg.mn_Node.ln_Type = NT_MESSAGE;   /* make up a message, */
  213.             p->BBSMsg->ADS_Msg.mn_Length       = sizeof(struct ADoorMessage);  /* including the replyport.  */
  214.             p->BBSMsg->ADS_Msg.mn_ReplyPort    = p->BBSreplyport;
  215.  
  216.             ret = 1;    /* succes */
  217.          }else{
  218.             if (!p->quiet) printf("Couldn't get memory.\n");
  219.          }
  220.       }else{
  221.          if (!p->quiet) printf("Couldn't create BBSreplyport.\n");
  222.       }
  223.    }else{
  224.       if (!p->quiet) printf("Got an unvalid node number '%d'\n", p->node);
  225.    }
  226.  
  227.    if (ret == 0)  RemovePort(p);
  228.  
  229.    return ret;
  230. }
  231.  
  232.  
  233. int  RemovePort(struct ADS_Data *p)
  234. {
  235.    int ret = 0;
  236.  
  237.    if (p->BBSMsg)        FreeMem    ( p->BBSMsg, sizeof(struct ADoorMessage));
  238.    if (p->BBSreplyport)  DeletePort ( p->BBSreplyport);
  239.  
  240.    return ret;
  241. }
  242.  
  243.  
  244.  
  245.  
  246.  
  247.  
  248. int  DropCarrier(struct ADS_Data *p)
  249. {
  250.    p->BBSMsg->ADS_Command     =   ADSC_DROP_CARRIER;
  251.    return SendMessage( p );
  252. }
  253.  
  254.  
  255. int  PrintToLog(struct ADS_Data *p, char *string)
  256. {
  257.    p->BBSMsg->ADS_Command     =   ADSC_STRING_TO_LOG;
  258.    strcpy (p->BBSMsg->ADS_String , string);
  259.    return SendMessage( p );
  260. }
  261.  
  262.  
  263. /* an extension (.TXT .ANSI .RIP etc.) is not needed */
  264.  
  265. int  TypeFile(struct ADS_Data *p, char *string)
  266. {
  267.    p->BBSMsg->ADS_Command     =   ADSC_TYPE_FILE;
  268.    strcpy (p->BBSMsg->ADS_String , string);
  269.    return SendMessage( p );
  270. }
  271.  
  272. int  GetTimeOnline(struct ADS_Data *p)
  273. {
  274.    int res = -1;
  275.  
  276.    p->BBSMsg->ADS_Command     =   ADSC_GET_TIME_ONLINE;
  277.    res = SendMessage( p );
  278.  
  279.    if (res >= 0){
  280.       return p->BBSMsg->ADS_Data_word;
  281.    }else{
  282.       return -1;
  283.    }
  284. }
  285.  
  286. int  IncreaseTimeOnline(struct ADS_Data *p, int time)
  287. {
  288.    p->BBSMsg->ADS_Command     =   ADSC_CHANGE_TIME_ONLINE;
  289.    p->BBSMsg->ADS_SubCommand  =   1;    /* Increase */
  290.    p->BBSMsg->ADS_Data_word   =   time;
  291.    return SendMessage( p );
  292. }
  293.  
  294. int  DecreaseTimeOnline(struct ADS_Data *p, int time)
  295. {
  296.    p->BBSMsg->ADS_Command     =   ADSC_CHANGE_TIME_ONLINE;
  297.    p->BBSMsg->ADS_SubCommand  =   0;    /* Decrease */
  298.    p->BBSMsg->ADS_Data_word   =   time;
  299.    return SendMessage( p );
  300. }
  301.  
  302.  
  303.  
  304.  
  305.  
  306. int  Download(struct ADS_Data *p)
  307. {
  308.    p->BBSMsg->ADS_Command     =   ADSC_DOWNLOAD_DOS_FILES;
  309.    return SendMessage( p );
  310. }
  311.  
  312.  
  313. int  MarkFile(struct ADS_Data *p, char *str)   /* 79 letters max */
  314. {
  315.    p->BBSMsg->ADS_Command     =   ADSC_MARK_DOS_FILE;
  316.    strcpy (p->BBSMsg->ADS_String , str);
  317.    return SendMessage( p );
  318. }
  319.  
  320.  
  321. int  UnmarkAllFiles(struct ADS_Data *p)
  322. {
  323.    p->BBSMsg->ADS_Command     =   ADSC_UNMARK_ALL_DOSFILES;
  324.    return SendMessage( p );
  325. }
  326.  
  327.  
  328.  
  329.  
  330.  
  331. int  PageSysop(struct ADS_Data *p)
  332. {
  333.    p->BBSMsg->ADS_Command     =   ADSC_PAGE_SYSOP;
  334.    return SendMessage( p );
  335. }
  336.  
  337.  
  338.  
  339. /* If you want to play a sample multiple times , increase SubCommand */
  340.  
  341.  
  342. int  PlaySample(struct ADS_Data *p, char *sample)
  343. {
  344.    p->BBSMsg->ADS_Command     =   ADSC_PLAY_SAMPLE;
  345.    p->BBSMsg->ADS_SubCommand  =   1;
  346.  
  347.    /* strcpy (p->BBSMsg->ADS_String , sample); */
  348.    sprintf (p->BBSMsg->ADS_String, "tron:samples/%s", sample);
  349.    return SendMessage( p );
  350. }
  351.  
  352. int  PlaySampleNum  (struct ADS_Data *p, char *sample, int num)
  353. {
  354.    p->BBSMsg->ADS_Command     =   ADSC_PLAY_SAMPLE;
  355.    p->BBSMsg->ADS_SubCommand  =   num;
  356.  
  357.    /* strcpy (p->BBSMsg->ADS_String , sample); */
  358.    sprintf (p->BBSMsg->ADS_String, "tron:samples/%s", sample);
  359.    return SendMessage( p );
  360. }
  361.  
  362. int   CheckSysopAvailable(struct ADS_Data *p)
  363. {
  364.    int res = -1;
  365.  
  366.    p->BBSMsg->ADS_Command     =   ADSC_CHECK_SYSOP_AVAILABLE;
  367.    res = SendMessage( p );
  368.  
  369.    if (res >= 0){
  370.       return (p->BBSMsg->ADS_Data_word);
  371.    }else{
  372.       return -1;
  373.    }
  374. }
  375.  
  376.  
  377. /* mode == 0   ->   Normal mode   8 bit ASCII  */
  378. /* mode == 1   ->   Chat mode     7 bit ASCII , MSB is the source of character */
  379.  
  380. int  SplitChatMode(struct ADS_Data *p, int mode)
  381. {
  382.    p->IDMode                  =   mode & 1;
  383.    p->BBSMsg->ADS_Command     =   ADSC_SPLIT_CHAT_MODE;
  384.    p->BBSMsg->ADS_SubCommand  =   mode & 1;
  385.    return SendMessage( p );
  386. }
  387.  
  388.  
  389.  
  390. int  GetUserStringField(struct ADS_Data *p, int field, char *string)
  391. {
  392.    int res = -1;
  393.  
  394.    if (field >= 64 && field <= 127){
  395.       p->BBSMsg->ADS_Command     =   ADSC_GET_USER_DATA;
  396.       p->BBSMsg->ADS_SubCommand  =   field;
  397.       res =  SendMessage( p );
  398.  
  399.       if (res >= 0){
  400.          strcpy(string, p->BBSMsg->ADS_String);
  401.       }
  402.    }
  403.    return res;
  404. }
  405.  
  406. int  GetUserNumericalField(struct ADS_Data *p, int field, ULONG *var)
  407. {
  408.    int res = -1;
  409.  
  410.    if (field > 128){
  411.       p->BBSMsg->ADS_Command     =   ADSC_GET_USER_DATA;
  412.       p->BBSMsg->ADS_SubCommand  =   field;
  413.       res =  SendMessage( p );
  414.  
  415.       if (res >= 0){
  416.          *var = p->BBSMsg->ADS_Data_long;
  417.       }
  418.    }
  419.    return res;
  420. }
  421.  
  422. int  ChangeUserStringField(struct ADS_Data *p, int field, char *string)
  423. {
  424.    int res = -1;
  425.  
  426.    if (field >= 64 && field <= 127){
  427.       p->BBSMsg->ADS_Command     =   ADSC_CHANGE_USER_DATA;
  428.       p->BBSMsg->ADS_SubCommand  =   field;
  429.       strcpy(p->BBSMsg->ADS_String, string);
  430.       res =  SendMessage( p );
  431.    }
  432.    return res;
  433. }
  434.  
  435.  
  436. int  GetBaudRate(struct ADS_Data *p, UWORD *local, ULONG *baudrate)
  437. {
  438.    int res = 0;
  439.  
  440.    p->BBSMsg->ADS_Command     =   ADSC_GET_SYSTEM_DATA;
  441.    p->BBSMsg->ADS_SubCommand  =   1;
  442.    res =  SendMessage( p );
  443.  
  444.    *local    = p->BBSMsg->ADS_Data_word;
  445.    *baudrate = p->BBSMsg->ADS_Data_long;
  446.  
  447.    return res;
  448. }
  449.  
  450.  
  451.  
  452.  
  453.  
  454.  
  455.  
  456. int  ChangeUserNumericalField(struct ADS_Data *p, int field, ULONG var)
  457. {
  458.    int res = -1;
  459.  
  460.    if (field > 128){
  461.       p->BBSMsg->ADS_Command     =   ADSC_CHANGE_USER_DATA;
  462.       p->BBSMsg->ADS_SubCommand  =   field;
  463.       p->BBSMsg->ADS_Data_long   =   var;
  464.       res =  SendMessage( p );
  465.  
  466.    }
  467.    return res;
  468. }
  469.  
  470.  
  471. int  FlushBuffer(struct ADS_Data *p)
  472. {
  473.    p->BBSMsg->ADS_Command     =   ADSC_FLUSH_BUFFER;
  474.    return SendMessage( p );
  475. }
  476.  
  477.  
  478. int  PushIntoBuffer(struct ADS_Data *p, char *str)   /* 79 letters max */
  479. {
  480.    p->BBSMsg->ADS_Command     =   ADSC_PUSHINTOBUFFER;
  481.    strcpy (p->BBSMsg->ADS_String , str);
  482.    return SendMessage( p );
  483. }
  484.  
  485.  
  486.  
  487. int  SendMessage(struct ADS_Data *p)  /* int node, struct ADoorMessage *Msg */
  488. {
  489.    struct ADoorMessage  *reply;
  490.    int    result = 0;
  491.    char   portname[20];
  492.  
  493.    sprintf(portname , "tronadoor%d", p->node);
  494.  
  495.    if (SafePutToPort((struct Message *) p->BBSMsg,  portname )){
  496.       WaitPort(p->BBSreplyport);
  497.       if (reply = (struct ADoorMessage *) GetMsg(p->BBSreplyport)){
  498.          result = p->BBSMsg->ADS_Result;
  499.       }else{
  500.          /* print("Error.\n"); */
  501.          result = -3;
  502.       }
  503.    }else{
  504.       if (!p->quiet) printf("Can't find BBS node %d.\n", p->node);
  505.       result = -2;
  506.    }
  507.  
  508.    return result;
  509. }
  510.  
  511.  
  512.  
  513. int  SafePutToPort(struct Message *message, STRPTR portname)
  514. {
  515.    struct MsgPort *port;
  516.  
  517.    Forbid();
  518.    port = FindPort (portname);
  519.    if (port) PutMsg(port, message);
  520.    Permit();
  521.    return(port ? TRUE : FALSE);    /* FALSE if the port was not found */
  522. }
  523.  
  524.  
  525.  
  526.  
  527.  
  528. /*===(  ANSI code  )=================================*/
  529.  
  530.  
  531. #define  apri2buf  printf          /* Buffer code removed    */
  532.                                    /* color buffer inplace   */
  533.                                    /* cursor buffer removed  */
  534.  
  535.  
  536. void cursxy(struct DoorIO *p, int x,int y)
  537. {
  538.    if (y == 1 && x == 1){
  539.       printf("\x1b[H"); 
  540.    }else{
  541.       printf("\x1b[%d;%dH", p->my = y, p->mx = x); 
  542.    }
  543. }
  544.  
  545.  
  546.  
  547. /*
  548. void cursxy(struct DoorIO *p, int x,int y)
  549. {
  550.    if (y == 1 && x == 1){
  551.       apri2buf("\x1b[H"); 
  552.       my = y; mx = x;
  553.    }else{
  554.       if (y != my || x != mx){
  555.          if (y == my){
  556.             if (x > mx)
  557.                forward(x - mx,0);
  558.             else
  559.                backward(mx - x);
  560.          }else{
  561.             if (x == mx){
  562.                if (y > my)
  563.                   down(y - my);
  564.                else
  565.                   up(my - y);
  566.             }else{
  567.                if (x != mx || y != my){
  568.                   apri2buf("\x1b[%d;%dH", my=y, mx=x); 
  569.                }
  570.             }
  571.          }
  572.       }
  573.    }
  574. }
  575. */
  576.  
  577.  
  578. /*
  579. void forward(int n,int spaties)   /* checken: gaat niet voorbij EOL */
  580. {                                 /* als geen spaties: n < x-mx     */
  581.    register int tel;
  582.  
  583. /* if (n < 5 || spaties != 0)  */
  584.  
  585.    if (n < 0 || spaties != 0)      /* problems bij achtergrond kleur */
  586.       for (tel=0; tel<n; tel++)
  587.          apri2buf(" ");
  588.    else
  589.       if (n == 1) apri2buf("\x1b[C");
  590.       else        apri2buf("\x1b[%dC",n);
  591.  
  592.    mx += n;
  593.    if (mx > xmax)   mx = xmax;
  594. }
  595. */
  596.  
  597. /*
  598. void backward(int n)
  599. {
  600.    if (n == 1) apri2buf("\x1b[D");
  601.    else        apri2buf("\x1b[%dD",n);
  602.    mx -= n;
  603.    if (mx < 1)   mx = 1;
  604. }
  605. */
  606.  
  607. /*
  608. void down(int n)
  609. {
  610.    if (n == 1) apri2buf("\x1b[B");
  611.    else        apri2buf("\x1b[%dB",n);
  612.    my += n;
  613.    if (my > ymax)   my = ymax;
  614. }
  615. */
  616.  
  617. /*
  618. void up(int n)
  619. {
  620.    if (n == 1) apri2buf("\x1b[A");
  621.    else        apri2buf("\x1b[%dA",n);
  622.    my -= n;
  623.    if (my < 1)   my = 1;
  624. }
  625. */
  626.  
  627.  
  628.  
  629. void col(struct DoorIO *p, int fc,int bc)
  630. {
  631.    int high;       /* is de voorgrond color high intensity ?  */
  632.    int h = 0, f = 0, b = 0;
  633.  
  634.    if (fc > 7){           /* gewone of High intensity colors (Bold) */
  635.       high = 1;
  636.       fc = fc + 22;       /* waarde van 30-37 */
  637.    }else{
  638.       high = 0;
  639.       fc = fc + 30;       /* waarde van 30-37 */
  640.    }
  641.  
  642.    if (bc > 7) bc += 32;  /* waarde van 40-47 */
  643.           else bc += 40;
  644.  
  645.    if (p->mhigh != high)   h = 1;
  646.    if (p->mfc   != fc  )   f = 1;
  647.    if (p->mbc   != bc  )   b = 1;
  648.  
  649.    /* stel mfc=fc en mbc=bc en mhigh!=high dan kleurverandering !! */
  650.  
  651.        /* als 2 kleuren veranderen of de 0m code moet worden   */
  652.        /* gegeven (intensiteit verandering met low intensity)  */
  653.        /* dan beide kleuren veranderen                         */
  654.  
  655.    if ( f || b || h ){         /* iets veranderen  ?*/
  656.       apri2buf("\x1b[");
  657.       if (( f && b ) || ( b && h ) || ( high == 0 && h )){  /* beide kleuren  ?*/
  658.          if ( h ){
  659.             apri2buf("%d;", p->mhigh = high); 
  660.          }
  661.          apri2buf("%d;%dm", p->mfc = fc, p->mbc = bc);
  662.       }else{                           /* anders 1 kleur veranderen */
  663.          if ( f || h ){                /* voorgrond kleur   */
  664.             if ( h ){                  /* indien voorgrond en intensiteit    */
  665.                apri2buf("1;");         /* verandering geef de 1m (low int.)  */
  666.                p->mhigh = 1;
  667.             }
  668.             apri2buf("%dm", p->mfc = fc);
  669.          }else{
  670.             apri2buf("%dm", p->mbc = bc);        /* achtergrond kleur  */
  671.          }
  672.       }
  673.    }
  674. }
  675.  
  676. void fcol(struct DoorIO *p, int fc)
  677. {
  678.    int high;       /* is de voorgrond color high intensity ?  */
  679.    /* int oc; */   /* De output color (30-37) */
  680.  
  681.    if (fc > 7){         /* gewone of High intensity colors (Bold) */
  682.       high = 1;
  683.       fc = fc + 22;     /* waarde van 30-37 */
  684.    }else{
  685.       high = 0;
  686.       fc = fc + 30;     /* waarde van 30-37 */
  687.    }
  688.  
  689.    /* stel mfc=fc en mbc=bc en mhigh!=high dan kleurverandering !! */
  690.  
  691.    if (p->mfc != fc || p->mhigh != high){     /* iets veranderen ?*/
  692.       apri2buf("\x1b[");
  693.       if (high == 0){
  694.          if (p->mhigh != high){      /* als int. verandering en lage int. */
  695.             apri2buf("0;%d;",p->mbc);  /* dan beide kleuren uitgeven  */
  696.             p->mhigh = 0;            /* maar eerst intensiteit code */
  697.          }
  698.          apri2buf("%dm", p->mfc = fc);
  699.       }else{
  700.          if (p->mhigh != high){      /* anders alleen voorgrond kleur    */
  701.             apri2buf("1;");         /* en indien nodig bold code geven  */
  702.             p->mhigh = 1;
  703.          }
  704.          apri2buf("%dm", p->mfc = fc);
  705.       }
  706.    }
  707. }
  708.  
  709. void bcol(struct DoorIO *p, int bc)
  710. {
  711.    if (bc > 7)           /*  if high. int color         */
  712.       bc = bc + 32;      /*  nie goed met 8 verlagen    */
  713.    else
  714.       bc = bc + 40;      /*  background color is 40-47  */
  715.    
  716.    if (p->mbc != bc){       /* moet Bkleur verandert ?     */
  717.       apri2buf("\x1b[%dm", p->mbc = bc);
  718.    }
  719. }
  720.  
  721. void atr(struct DoorIO *p, int atr)       /* attribute veranderen, geen invloed op kleur */
  722. {
  723.    apri2buf("\x1b[%d",atr); 
  724.    if (atr == 0){              /* als geen atribuut dan verandert kleur */
  725.       if (p->mhigh == 1)          /* esc[0;1;[mfc];[mbc]m  */
  726.          apri2buf(";1");
  727.       apri2buf(";%d;%d" ,p->mfc ,p->mbc );
  728.    }
  729.    apri2buf("m");
  730. }
  731.  
  732. void norm(struct DoorIO *p)        /* alle atributes uit, kleuren normaal */
  733. {                      /* kleuren: grijs op zwart              */
  734.    apri2buf("\x1b[0m");
  735.    p->mfc   = 37;
  736.    p->mbc   = 40;
  737.    p->mhigh =  0;
  738. }
  739.  
  740. void cls(struct DoorIO *p)     /* cls en cursor home (home mandatory!!) */
  741. {
  742.    apri2buf("\x1b[H\x1b[J");         /* official ansi , clear screen en */
  743.    p->my = p->mx = 1;                 /* cursor op home positie */
  744. }
  745.  
  746.  
  747.  
  748.  
  749. /*===( Simple ANSI code )=================================*/
  750.  
  751. /*
  752. void col(int fc,int bc)
  753. {
  754.    if (fc > 7){
  755.       printf("\x1b[1;%d;%dm", fc + 22 , bc + 40);
  756.    }else{
  757.       printf("\x1b[0;%d;%dm", fc + 30 , bc + 40);
  758.    }
  759. }
  760.  
  761. void cursxy(int x,int y)
  762. {
  763.    if (y == 1 && x == 1){
  764.       printf("\x1b[H"); 
  765.    }else{
  766.       printf("\x1b[%d;%dH", y, x); 
  767.    }
  768. }
  769.  
  770. void fcol(int fc)
  771. {
  772.    if (fc > 7){
  773.       printf("\x1b[1;%dm", fc + 22);
  774.    }else{
  775.       printf("\x1b[0;%dm", fc + 30);
  776.    }
  777. }
  778.  
  779. void bcol(int bc)
  780. {
  781.    printf("\x1b[%dm", bc + 40);
  782. }
  783.  
  784. void atr(int atr)
  785. {
  786.    printf("\x1b[%dm", atr);
  787. }
  788.  
  789. void norm(void)
  790. {
  791.    printf("\x1b[0m");
  792. }
  793.  
  794. void cls(void)
  795. {
  796.    printf("\x1b[H\x1b[J"); 
  797. }
  798.  
  799. */
  800.